
/*
 * To change this template, choose Tools | Templates
 * and open the template in the editor.
 */
package itm.dao.convocatorias;

//~--- non-JDK imports --------------------------------------------------------
import itm.exception.ControlException;

import itm.exception.DAOException;
import itm.vo.convocatorias.ConvocatoriaVO;
import itm.vo.convocatorias.PostuladosConvocatoriaVO;
import itm.vo.convocatorias.ProductoConvocatoriaVO;
import itm.vo.convocatorias.RubroVO;
import itm.vo.grupoInvestigacion.GrupoInvestigacionVO;
import itm.vo.personas.PersonaVO;
import itm.vo.prodructos.ProductoVO;
import itm.vo.proyectosInvestigacion.ProyectoInvestigacionVO;

//~--- JDK imports ------------------------------------------------------------

import java.sql.CallableStatement;
import java.sql.Connection;
import java.sql.ResultSet;
import java.sql.SQLException;

import java.util.ArrayList;
import java.util.List;
import java.util.logging.Level;
import java.util.logging.Logger;

/**
 *
 * @author BISA19
 */
public class ConvocatoriaDAO {

    private CallableStatement callStmt = null;
    private ResultSet res = null;
    private String sql = "";
    Connection dbConexion;

    public ConvocatoriaDAO(Connection dbConexion) {
        this.dbConexion = dbConexion;
    }

    public String insertarResultadoCOnvocatoria(ConvocatoriaVO convocatoriaVO, long idPostulado) throws DAOException {
        String respuesta = "";
        try {

            sql = "{call ITM_INSERTAR_RESULTADO_CONVOCATORIA(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setLong(2, idPostulado);
            callStmt.setString(3, convocatoriaVO.getIdConvocatoria());
            callStmt.execute();
            respuesta = callStmt.getString(1);
            return respuesta;
        } catch (SQLException ex) {
            Logger.getLogger(ConvocatoriaDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al ingresar resultados", ex);
        }
    }

    public List<PostuladosConvocatoriaVO> listarPostulados(ConvocatoriaVO convocatoriaVO) throws SQLException {
        List<PostuladosConvocatoriaVO> listaPostulados = new ArrayList<PostuladosConvocatoriaVO>();
        PostuladosConvocatoriaVO postuladosConvocatoriaVO;

        try {
            sql = "{call ITM_LISTAR_POSTULADOS_CONVOCATORIA(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setString(1, convocatoriaVO.getIdConvocatoria());
            res = callStmt.executeQuery();

            while (res.next()) {
                postuladosConvocatoriaVO = new PostuladosConvocatoriaVO();
                postuladosConvocatoriaVO.setIdProyecto(res.getInt(1));
                postuladosConvocatoriaVO.setNombreProyecto(res.getString(2));
                listaPostulados.add(postuladosConvocatoriaVO);
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return listaPostulados;
    }

    public List<RubroVO> llenarRubroSF() throws ControlException, SQLException {
        List<RubroVO> listaRubroSF = new ArrayList<RubroVO>();
        RubroVO rubroVO;

        try {
            sql = "{call ITM_LLENAR_LISTA_RUBRO_SF()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                rubroVO = new RubroVO();
                rubroVO.setIdRubro(res.getString(1));
                rubroVO.setNombreRubro(res.getString(2));
                listaRubroSF.add(rubroVO);
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return listaRubroSF;
    }

    public List<RubroVO> llenarRubroNF() throws ControlException, SQLException {
        List<RubroVO> listaRubroNF = new ArrayList<RubroVO>();
        RubroVO rubroVO;

        try {
            sql = "{call ITM_LLENAR_LISTA_RUBRO_NF()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                rubroVO = new RubroVO();
                rubroVO.setIdRubro(res.getString(1));
                rubroVO.setNombreRubro(res.getString(2));
                listaRubroNF.add(rubroVO);
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return listaRubroNF;
    }

    public List<ProductoVO> llenarProducto() throws ControlException, SQLException {
        List<ProductoVO> listaProducto = new ArrayList<ProductoVO>();
        ProductoVO productoVO;

        try {
            sql = "{call ITM_LLENAR_LISTA_PRODUCTO()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                productoVO = new ProductoVO();
                productoVO.setIdProducto(res.getString(1));
                productoVO.setNombreProducto(res.getString(2));
                listaProducto.add(productoVO);
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return listaProducto;
    }

    public String crearConvocatoria(ConvocatoriaVO convocatoriaVO) throws ControlException, SQLException {
        String errorM = "";

        try {
            sql = "{call ITM_CREAR_CONVOCATORIA(?,?,?,?,?,?,?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, convocatoriaVO.getNombreConvocatoria());
            callStmt.setString(3, convocatoriaVO.getObjetivo());
            callStmt.setString(4, convocatoriaVO.getDirigidoA());
            callStmt.setString(5, convocatoriaVO.getRequisitos());
            callStmt.setDate(6, convocatoriaVO.getRegistrado());
            callStmt.setDate(7, convocatoriaVO.getCierre());
            callStmt.setDate(8, convocatoriaVO.getPublicacionR());
            callStmt.registerOutParameter(9, java.sql.Types.VARCHAR);
            callStmt.execute();
            errorM = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return errorM;
    }

    public String crearProdcutoConv(ProductoConvocatoriaVO prodConvVO) throws ControlException, SQLException {
        String errorM = "";

        try {
            sql = "{call ITM_CREAR_PRODUCTO_CONVOCATORIA(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, prodConvVO.getIdConvovatoria());
            callStmt.setString(3, prodConvVO.getIdProducto());
            callStmt.execute();
            errorM = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return errorM;
    }

    public List<ProyectoInvestigacionVO> listarProyectos() throws ControlException, SQLException {
        List<ProyectoInvestigacionVO> listaProyecto = new ArrayList<ProyectoInvestigacionVO>();
        ProyectoInvestigacionVO proyectoInvVO;

        try {
            sql = "{call ITM_LISTAR_PROYECTOS()}";
            callStmt = dbConexion.prepareCall(sql);
            res = callStmt.executeQuery();

            while (res.next()) {
                proyectoInvVO = new ProyectoInvestigacionVO();
                proyectoInvVO.setIdProyecto(res.getInt(1));
                proyectoInvVO.setTituloProyecto(res.getString(2));
                listaProyecto.add(proyectoInvVO);
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return listaProyecto;
    }

    public List<ConvocatoriaVO> consultarConvocatorias(ConvocatoriaVO convocatoriaVO)
            throws ControlException, SQLException {
        List<ConvocatoriaVO> listaConvocatorias = new ArrayList<ConvocatoriaVO>();

        try {
            sql = "{call ITM_CONSULTAR_CONVOCATORIAS(?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setString(1, convocatoriaVO.getEstado());
            callStmt.setString(2, convocatoriaVO.getNombreConvocatoria());
            res = callStmt.executeQuery();

            // if
            while (res.next()) {
                convocatoriaVO = new ConvocatoriaVO();

                // personaVO.setIdTipoIdentificacion(res.getString(1));
                convocatoriaVO.setIdConvocatoria(res.getString(1));
                convocatoriaVO.setNombreConvocatoria(res.getString(2));
                listaConvocatorias.add(convocatoriaVO);
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return listaConvocatorias;
    }

    public ConvocatoriaVO consultarConvocatoria(ConvocatoriaVO convocatoriaVO) throws ControlException, SQLException {

        // List<PersonaVO> listaPersonas = new ArrayList<PersonaVO>();
        try {
            sql = "{call ITM_CONSULTAR_CONVOCATORIA(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setString(1, convocatoriaVO.getIdConvocatoria());
            res = callStmt.executeQuery();

            if (res.next()) {
                convocatoriaVO.setIdConvocatoria(res.getString(1));
                convocatoriaVO.setNombreConvocatoria(res.getString(2));
                convocatoriaVO.setObjetivo(res.getString(3));
                convocatoriaVO.setDirigidoA(res.getString(4));
                convocatoriaVO.setRequisitos(res.getString(5));
                convocatoriaVO.setRegistrado(res.getDate(6));
                convocatoriaVO.setCierre(res.getDate(7));
                convocatoriaVO.setPublicacionR(res.getDate(8));
                convocatoriaVO.setEstado(res.getString(9));
            }
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return convocatoriaVO;
    }

    public String actualizarConvocatoria(ConvocatoriaVO convocatoriaVO) throws ControlException, SQLException {
        String errorM = "";

        try {
            sql = "{call ITM_ACTUALIZAR_CONVOCATORIA(?,?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.registerOutParameter(1, java.sql.Types.VARCHAR);
            callStmt.setString(2, convocatoriaVO.getIdConvocatoria());
            callStmt.setString(3, convocatoriaVO.getEstado());
            callStmt.execute();
            errorM = callStmt.getString(1);
        } catch (SQLException ce) {
            ce.getStackTrace();
        }

        return errorM;
    }

    public void eliminarConvocatoria(ConvocatoriaVO convocatoriaVO) throws DAOException {
        try {
            sql = "{call PRC_ITM_ELIMINAR_CONVOCATORIA(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, Long.parseLong(convocatoriaVO.getIdConvocatoria()));
            callStmt.execute();
        } catch (SQLException ex) {
            Logger.getLogger(ConvocatoriaDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al eliminar convocatoria", ex);
        }
    }

    public List<GrupoInvestigacionVO> consultarConvocatoriaGrupo(long idConvocatoria) throws DAOException {
        List<GrupoInvestigacionVO> listaGrupos = new ArrayList<GrupoInvestigacionVO>();
        GrupoInvestigacionVO grupoInvestigacionVO;
        try {
            sql = "{call PRC_ITM_CONSULTAR_CONVOCATORIA_GRUPO(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idConvocatoria);
            res = callStmt.executeQuery();
            while (res.next()) {
                grupoInvestigacionVO = new GrupoInvestigacionVO();
                grupoInvestigacionVO.setTituloProyecto(res.getString(3));
                grupoInvestigacionVO.setIdGrupo(res.getInt(4));
                grupoInvestigacionVO.setNombreGrupo(res.getString(5));
                listaGrupos.add(grupoInvestigacionVO);
            }
            return listaGrupos;
        } catch (SQLException ex) {
            Logger.getLogger(ConvocatoriaDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar grupos por convocatoria", ex);
        }
    }

    public List<PersonaVO> consultarConvocatoriaPersona(long idConvocatoria) throws DAOException {
        List<PersonaVO> listaPersonas = new ArrayList<PersonaVO>();
        PersonaVO personaVO;
        try {
            sql = "{call PRC_ITM_CONSULTAR_CONVOCATORIA_PERSONA(?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idConvocatoria);
            res = callStmt.executeQuery();
            while (res.next()) {
                personaVO = new PersonaVO();
                personaVO.setTituloProyecto(res.getString(3));
                personaVO.setIdPersona(res.getString(4));
                personaVO.setNombrePersona(res.getString(5));
                listaPersonas.add(personaVO);
            }
            return listaPersonas;
        } catch (SQLException ex) {
            Logger.getLogger(ConvocatoriaDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar personas por convocatoria", ex);
        }
    }

    public String existeResultadoConvocatoria(long idConvocatoria) throws DAOException {
        try {
            sql = "{call PRC_ITM_EXISTE_RESULTADO_CONVOCATORIA(?,?)}";
            callStmt = dbConexion.prepareCall(sql);
            callStmt.setLong(1, idConvocatoria);
            callStmt.registerOutParameter(2, java.sql.Types.VARCHAR);
            callStmt.execute();
            return callStmt.getString(2);
        } catch (SQLException ex) {
            Logger.getLogger(ConvocatoriaDAO.class.getName()).log(Level.SEVERE, null, ex);
            throw new DAOException("Error al consultar", ex);
        }
    }
}
